This and the below addition of !! aren't strictly needed but I spotted every other variable in this block returns a boolean so I figured these should too

the thing inside forwardRef is not a component, and should not be identified as such. forwardRef callbacks take props and ref, which isn't what components take.

Gotcha, thanks for the clarification :)

In that case I think there is something off with the Component detection, as this testcase identifies two components (as found by doing a console.log(components.list()) in the Program:exit function in the display-name rule). It sounds like it should only identify one - possibly the outer call to React.memo. This also occurs on master too.

At risk of creating one of those magic eye "how many triangles can you see puzzles", how many components should be identified in the following pieces of code?

// Currently reports 1 component - I *think* that is the result of calling React.memo, and the argument that is passed into React.memo is ignored, can you confirm?
const ComponentWithMemo = React.memo(function Component({ world }) {
  return <div>Hello {world}</div>
})

// currently reports 1 component - The result of calling React.forwardRef is a component, the argument that is passed into React.forwardRef isn't a component
const ComponentWithForwardRef = React.forwardRef(function NotAComponent({ world }, ref) {
  return <div>Hello {world}</div>
}, )

// Should this report one or two components found?
// Currently it seems to identify two, - The result of calling React.memo, and the result of React.forwardRef, but that seems at odds with how React.memo worked previously where it didn't count the component that was the argument passed into React.memo
const ComponentWithMemoAndForwardRef = React.memo(React.forwardRef(function Component({ world }, ref) {
  return <div>Hello {world}</div>
}))

I don't understand how the internal Component identification heuristics works and what knock-on effects changing them would have. It looks like 98d4bf3 did some work relating to this but I'm not sure how to fix my above confusion

this shouldn't be fixed because it's not broken; forwardRef is a component but does not accept one; it accepts a callback that takes props and ref.

I think I'm referring to a slightly different issue. I'm referring how React.memo handles accepting a Component vs the result of calling forwardRef.

When inspecting the MemoFunction and MemoThenForwardRefFunction
items on https://codesandbox.io/s/awesome-paper-hh0wh?module=App.js I end up with the following in my react devtools:

Note that calling React.memo with a function component defined inline

const MemoFunction = React.memo(function MemoFunction() {
  return <div>MemoFunction</div>;
});

Results in in the name MemoFunction [memo] in the component tree.

However calling React.memo with an invocation of React.forwardRef (which returns a Component)

const MemoThenForwardRefFunction = React.memo(
  React.forwardRef(function MemoThenForwardRefFunction() {
    return <div>MemoThenForwardRefFunction</div>;
  })
);

Results in the name Anonymous in the component tree - Given that the result of an unwrapped call to React.forwardRef has a meaningful name, I would have expected that to have been picked up by React.memo

I've raised this upstream as facebook/react#16722